(function() {"use strict";var __module = CC_EDITOR ? module : {exports:{}};var __filename = 'preview-scripts/assets/common/script/basic/rankNetwork/pomeloBuild.js';var __require = CC_EDITOR ? function (request) {return cc.require(request, require);} : function (request) {return cc.require(request, __filename);};function __define (exports, require, module) {"use strict";
cc._RF.push(module, 'fcbc4JxLPtK25TfU3NaoI+E', 'pomeloBuild', __filename);
// common/script/basic/rankNetwork/pomeloBuild.js

'use strict';

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

/**
 * 此文件来自于pomelo helloworld lib/build/build.js
 */
/**
 * hasOwnProperty.
 */

var has = Object.prototype.hasOwnProperty;

var pomeloBuild = cc.Class({
    onLoad: function onLoad() {
        /**
         * Registered modules.
         */

        this.modules = {};

        /**
         * Registered aliases.
         */

        this.aliases = {};
    },

    requirePomelo: function requirePomelo(path, parent, orig) {
        var resolved = this.resolve(path);

        // lookup failed
        if (null === resolved) {
            orig = orig || path;
            parent = parent || 'root';
            var err = new Error('Failed to requirePomelo "' + orig + '" from "' + parent + '"');
            err.path = orig;
            err.parent = parent;
            err.requirePomelo = true;
            throw err;
        }

        var module = this.modules[resolved];

        // perform real requirePomelo()
        // by invoking the module's
        // registered function
        if (!module.exports) {
            module.exports = {};
            module.client = module.component = true;
            module.call(this, module.exports, this.relative(resolved), module);
        }

        return module.exports;
    },

    /**
     * Resolve `path`.
     *
     * Lookup:
     *
     *   - PATH/index.js
     *   - PATH.js
     *   - PATH
     *
     * @param {String} path
     * @return {String} path or null
     * @api private
     */

    resolve: function resolve(path) {
        if (path.charAt(0) === '/') path = path.slice(1);
        var index = path + '/index.js';

        var paths = [path, path + '.js', path + '.json', path + '/index.js', path + '/index.json'];

        for (var i = 0; i < paths.length; i++) {
            var resolvePath = paths[i];
            if (has.call(this.modules, resolvePath)) return resolvePath;
        }

        if (has.call(this.aliases, index)) {
            return this.aliases[index];
        }
    },

    /**
     * Normalize `path` relative to the current path.
     *
     * @param {String} curr
     * @param {String} path
     * @return {String}
     * @api private
     */

    normalize: function normalize(curr, path) {
        var segs = [];

        if ('.' !== path.charAt(0)) return path;

        curr = curr.split('/');
        path = path.split('/');

        for (var i = 0; i < path.length; ++i) {
            if ('..' === path[i]) {
                curr.pop();
            } else if ('.' !== path[i] && '' !== path[i]) {
                segs.push(path[i]);
            }
        }

        return curr.concat(segs).join('/');
    },

    /**
     * Register module at `path` with callback `definition`.
     *
     * @param {String} path
     * @param {Function} definition
     * @api private
     */

    register: function register(path, definition) {
        this.modules[path] = definition;
    },

    /**
     * Alias a module definition.
     *
     * @param {String} from
     * @param {String} to
     * @api private
     */

    alias: function alias(from, to) {
        if (!has.call(this.modules, from)) {
            throw new Error('Failed to alias "' + from + '", it does not exist');
        }
        this.aliases[to] = from;
    },

    /**
     * Return a requirePomelo function relative to the `parent` path.
     *
     * @param {String} parent
     * @return {Function}
     * @api private
     */

    relative: function relative(parent) {
        var p = this.normalize(parent, '..');

        /**
         * lastIndexOf helper.
         */

        function lastIndexOf(arr, obj) {
            var i = arr.length;
            while (i--) {
                if (arr[i] === obj) return i;
            }
            return -1;
        }

        /**
         * The relative requirePomelo() itself.
         */

        var selfPomelo = this;
        function localrequirePomelo(path) {
            var resolved = localrequirePomelo.resolve(path);
            return selfPomelo.requirePomelo(resolved, parent, path);
        }

        /**
         * Resolve relative to the parent.
         */

        localrequirePomelo.resolve = function (path) {
            var c = path.charAt(0);
            if ('/' === c) return path.slice(1);
            if ('.' === c) return selfPomelo.normalize(p, path);

            // resolve deps by returning
            // the dep in the nearest "deps"
            // directory
            var segs = parent.split('/');
            var i = lastIndexOf(segs, 'deps') + 1;
            if (!i) i = 0;
            path = segs.slice(0, i + 1).join('/') + '/deps/' + path;
            return path;
        };

        /**
         * Check if module is defined at `path`.
         */

        localrequirePomelo.exists = function (path) {
            return has.call(selfPomelo.modules, localrequirePomelo.resolve(path));
        };

        return localrequirePomelo;
    }
});

pomeloBuild.create = function () {
    var pomeloBuildObj = new pomeloBuild();
    pomeloBuildObj.onLoad();

    pomeloBuildObj.register("component-indexof/index.js", function (exports, requirePomelo, module) {

        var indexOf = [].indexOf;

        module.exports = function (arr, obj) {
            if (indexOf) return arr.indexOf(obj);
            for (var i = 0; i < arr.length; ++i) {
                if (arr[i] === obj) return i;
            }
            return -1;
        };
    });

    pomeloBuildObj.register("component-emitter/index.js", function (exports, requirePomelo, module) {

        /**
         * Module dependencies.
         */

        var index = requirePomelo('indexof');

        /**
         * Expose `Emitter`.
         */

        module.exports = Emitter;

        /**
         * Initialize a new `Emitter`.
         *
         * @api public
         */

        function Emitter(obj) {
            if (obj) return mixin(obj);
        };

        /**
         * Mixin the emitter properties.
         *
         * @param {Object} obj
         * @return {Object}
         * @api private
         */

        function mixin(obj) {
            for (var key in Emitter.prototype) {
                obj[key] = Emitter.prototype[key];
            }
            return obj;
        }

        /**
         * Listen on the given `event` with `fn`.
         *
         * @param {String} event
         * @param {Function} fn
         * @return {Emitter}
         * @api public
         */

        Emitter.prototype.on = function (event, fn) {
            this._callbacks = this._callbacks || {};
            (this._callbacks[event] = this._callbacks[event] || []).push(fn);
            return this;
        };

        /**
         * Adds an `event` listener that will be invoked a single
         * time then automatically removed.
         *
         * @param {String} event
         * @param {Function} fn
         * @return {Emitter}
         * @api public
         */

        Emitter.prototype.once = function (event, fn) {
            var self = this;
            this._callbacks = this._callbacks || {};

            function on() {
                self.off(event, on);
                fn.apply(this, arguments);
            }

            fn._off = on;
            this.on(event, on);
            return this;
        };

        /**
         * Remove the given callback for `event` or all
         * registered callbacks.
         *
         * @param {String} event
         * @param {Function} fn
         * @return {Emitter}
         * @api public
         */

        Emitter.prototype.off = Emitter.prototype.removeListener = Emitter.prototype.removeAllListeners = function (event, fn) {
            this._callbacks = this._callbacks || {};

            // all
            if (0 === arguments.length) {
                this._callbacks = {};
                return this;
            }

            // specific event
            var callbacks = this._callbacks[event];
            if (!callbacks) return this;

            // remove all handlers
            if (1 === arguments.length) {
                delete this._callbacks[event];
                return this;
            }

            // remove specific handler
            var i = index(callbacks, fn._off || fn);
            if (~i) callbacks.splice(i, 1);
            return this;
        };

        /**
         * Emit `event` with the given args.
         *
         * @param {String} event
         * @param {Mixed} ...
         * @return {Emitter}
         */

        Emitter.prototype.emit = function (event) {
            this._callbacks = this._callbacks || {};
            var args = [].slice.call(arguments, 1),
                callbacks = this._callbacks[event];

            if (callbacks) {
                callbacks = callbacks.slice(0);
                for (var i = 0, len = callbacks.length; i < len; ++i) {
                    callbacks[i].apply(this, args);
                }
            }

            return this;
        };

        /**
         * Return array of callbacks for `event`.
         *
         * @param {String} event
         * @return {Array}
         * @api public
         */

        Emitter.prototype.listeners = function (event) {
            this._callbacks = this._callbacks || {};
            return this._callbacks[event] || [];
        };

        /**
         * Check if this emitter has `event` handlers.
         *
         * @param {String} event
         * @return {Boolean}
         * @api public
         */

        Emitter.prototype.hasListeners = function (event) {
            return !!this.listeners(event).length;
        };
    });

    pomeloBuildObj.register("NetEase-pomelo-protocol/lib/protocol.js", function (exports, requirePomelo, module) {
        (function (exports, ByteArray, global) {
            var Protocol = exports;

            var PKG_HEAD_BYTES = 4;
            var MSG_FLAG_BYTES = 1;
            var MSG_ROUTE_CODE_BYTES = 2;
            var MSG_ID_MAX_BYTES = 5;
            var MSG_ROUTE_LEN_BYTES = 1;

            var MSG_ROUTE_CODE_MAX = 0xffff;

            var MSG_COMPRESS_ROUTE_MASK = 0x1;
            var MSG_TYPE_MASK = 0x7;

            var Package = Protocol.Package = {};
            var Message = Protocol.Message = {};

            Package.TYPE_HANDSHAKE = 1;
            Package.TYPE_HANDSHAKE_ACK = 2;
            Package.TYPE_HEARTBEAT = 3;
            Package.TYPE_DATA = 4;
            Package.TYPE_KICK = 5;

            Message.TYPE_REQUEST = 0;
            Message.TYPE_NOTIFY = 1;
            Message.TYPE_RESPONSE = 2;
            Message.TYPE_PUSH = 3;

            /**
             * pomele client encode
             * id message id;
             * route message route
             * msg message body
             * socketio current support string
             */
            Protocol.strencode = function (str) {
                var byteArray = new ByteArray(str.length * 3);
                var offset = 0;
                for (var i = 0; i < str.length; i++) {
                    var charCode = str.charCodeAt(i);
                    var codes = null;
                    if (charCode <= 0x7f) {
                        codes = [charCode];
                    } else if (charCode <= 0x7ff) {
                        codes = [0xc0 | charCode >> 6, 0x80 | charCode & 0x3f];
                    } else {
                        codes = [0xe0 | charCode >> 12, 0x80 | (charCode & 0xfc0) >> 6, 0x80 | charCode & 0x3f];
                    }
                    for (var j = 0; j < codes.length; j++) {
                        byteArray[offset] = codes[j];
                        ++offset;
                    }
                }
                var _buffer = new ByteArray(offset);
                copyArray(_buffer, 0, byteArray, 0, offset);
                return _buffer;
            };

            /**
             * client decode
             * msg String data
             * return Message Object
             */
            Protocol.strdecode = function (buffer) {
                var bytes = new ByteArray(buffer);
                var array = [];
                var offset = 0;
                var charCode = 0;
                var end = bytes.length;
                while (offset < end) {
                    if (bytes[offset] < 128) {
                        charCode = bytes[offset];
                        offset += 1;
                    } else if (bytes[offset] < 224) {
                        charCode = ((bytes[offset] & 0x3f) << 6) + (bytes[offset + 1] & 0x3f);
                        offset += 2;
                    } else {
                        charCode = ((bytes[offset] & 0x0f) << 12) + ((bytes[offset + 1] & 0x3f) << 6) + (bytes[offset + 2] & 0x3f);
                        offset += 3;
                    }
                    array.push(charCode);
                }
                var res = '';
                var chunk = 8 * 1024;
                var i;
                for (i = 0; i < array.length / chunk; i++) {
                    res += String.fromCharCode.apply(null, array.slice(i * chunk, (i + 1) * chunk));
                }
                res += String.fromCharCode.apply(null, array.slice(i * chunk));
                return res;
            };

            /**
             * Package protocol encode.
             *
             * Pomelo package format:
             * +------+-------------+------------------+
             * | type | body length |       body       |
             * +------+-------------+------------------+
             *
             * Head: 4bytes
             *   0: package type,
             *      1 - handshake,
             *      2 - handshake ack,
             *      3 - heartbeat,
             *      4 - data
             *      5 - kick
             *   1 - 3: big-endian body length
             * Body: body length bytes
             *
             * @param  {Number}    type   package type
             * @param  {ByteArray} body   body content in bytes
             * @return {ByteArray}        new byte array that contains encode result
             */
            Package.encode = function (type, body) {
                var length = body ? body.length : 0;
                var buffer = new ByteArray(PKG_HEAD_BYTES + length);
                var index = 0;
                buffer[index++] = type & 0xff;
                buffer[index++] = length >> 16 & 0xff;
                buffer[index++] = length >> 8 & 0xff;
                buffer[index++] = length & 0xff;
                if (body) {
                    copyArray(buffer, index, body, 0, length);
                }
                return buffer;
            };

            /**
             * Package protocol decode.
             * See encode for package format.
             *
             * @param  {ByteArray} buffer byte array containing package content
             * @return {Object}           {type: package type, buffer: body byte array}
             */
            Package.decode = function (buffer) {
                var bytes = new ByteArray(buffer);
                var type = bytes[0];
                var index = 1;
                var length = (bytes[index++] << 16 | bytes[index++] << 8 | bytes[index++]) >>> 0;
                var body = length ? new ByteArray(length) : null;
                copyArray(body, 0, bytes, PKG_HEAD_BYTES, length);
                return { 'type': type, 'body': body };
            };

            /**
             * Message protocol encode.
             *
             * @param  {Number} id            message id
             * @param  {Number} type          message type
             * @param  {Number} compressRoute whether compress route
             * @param  {Number|String} route  route code or route string
             * @param  {Buffer} msg           message body bytes
             * @return {Buffer}               encode result
             */
            Message.encode = function (id, type, compressRoute, route, msg) {
                // caculate message max length
                var idBytes = msgHasId(type) ? caculateMsgIdBytes(id) : 0;
                var msgLen = MSG_FLAG_BYTES + idBytes;

                if (msgHasRoute(type)) {
                    if (compressRoute) {
                        if (typeof route !== 'number') {
                            throw new Error('error flag for number route!');
                        }
                        msgLen += MSG_ROUTE_CODE_BYTES;
                    } else {
                        msgLen += MSG_ROUTE_LEN_BYTES;
                        if (route) {
                            route = Protocol.strencode(route);
                            if (route.length > 255) {
                                throw new Error('route maxlength is overflow');
                            }
                            msgLen += route.length;
                        }
                    }
                }

                if (msg) {
                    msgLen += msg.length;
                }

                var buffer = new ByteArray(msgLen);
                var offset = 0;

                // add flag
                offset = encodeMsgFlag(type, compressRoute, buffer, offset);

                // add message id
                if (msgHasId(type)) {
                    offset = encodeMsgId(id, idBytes, buffer, offset);
                }

                // add route
                if (msgHasRoute(type)) {
                    offset = encodeMsgRoute(compressRoute, route, buffer, offset);
                }

                // add body
                if (msg) {
                    offset = encodeMsgBody(msg, buffer, offset);
                }

                return buffer;
            };

            /**
             * Message protocol decode.
             *
             * @param  {Buffer|Uint8Array} buffer message bytes
             * @return {Object}            message object
             */
            Message.decode = function (buffer) {
                var bytes = new ByteArray(buffer);
                var bytesLen = bytes.length || bytes.byteLength;
                var offset = 0;
                var id = 0;
                var route = null;

                // parse flag
                var flag = bytes[offset++];
                var compressRoute = flag & MSG_COMPRESS_ROUTE_MASK;
                var type = flag >> 1 & MSG_TYPE_MASK;

                // parse id
                if (msgHasId(type)) {
                    var byte = bytes[offset++];
                    id = byte & 0x7f;
                    while (byte & 0x80) {
                        id <<= 7;
                        byte = bytes[offset++];
                        id |= byte & 0x7f;
                    }
                }

                // parse route
                if (msgHasRoute(type)) {
                    if (compressRoute) {
                        route = bytes[offset++] << 8 | bytes[offset++];
                    } else {
                        var routeLen = bytes[offset++];
                        if (routeLen) {
                            route = new ByteArray(routeLen);
                            copyArray(route, 0, bytes, offset, routeLen);
                            route = Protocol.strdecode(route);
                        } else {
                            route = '';
                        }
                        offset += routeLen;
                    }
                }

                // parse body
                var bodyLen = bytesLen - offset;
                var body = new ByteArray(bodyLen);

                copyArray(body, 0, bytes, offset, bodyLen);

                return {
                    'id': id, 'type': type, 'compressRoute': compressRoute,
                    'route': route, 'body': body
                };
            };

            var copyArray = function copyArray(dest, doffset, src, soffset, length) {
                if ('function' === typeof src.copy) {
                    // Buffer
                    src.copy(dest, doffset, soffset, soffset + length);
                } else {
                    // Uint8Array
                    for (var index = 0; index < length; index++) {
                        dest[doffset++] = src[soffset++];
                    }
                }
            };

            var msgHasId = function msgHasId(type) {
                return type === Message.TYPE_REQUEST || type === Message.TYPE_RESPONSE;
            };

            var msgHasRoute = function msgHasRoute(type) {
                return type === Message.TYPE_REQUEST || type === Message.TYPE_NOTIFY || type === Message.TYPE_PUSH;
            };

            var caculateMsgIdBytes = function caculateMsgIdBytes(id) {
                var len = 0;
                do {
                    len += 1;
                    id >>= 7;
                } while (id > 0);
                return len;
            };

            var encodeMsgFlag = function encodeMsgFlag(type, compressRoute, buffer, offset) {
                if (type !== Message.TYPE_REQUEST && type !== Message.TYPE_NOTIFY && type !== Message.TYPE_RESPONSE && type !== Message.TYPE_PUSH) {
                    throw new Error('unkonw message type: ' + type);
                }

                buffer[offset] = type << 1 | (compressRoute ? 1 : 0);

                return offset + MSG_FLAG_BYTES;
            };

            var encodeMsgId = function encodeMsgId(id, idBytes, buffer, offset) {
                var index = offset + idBytes - 1;
                buffer[index--] = id & 0x7f;
                while (index >= offset) {
                    id >>= 7;
                    buffer[index--] = id & 0x7f | 0x80;
                }
                return offset + idBytes;
            };

            var encodeMsgRoute = function encodeMsgRoute(compressRoute, route, buffer, offset) {
                if (compressRoute) {
                    if (route > MSG_ROUTE_CODE_MAX) {
                        throw new Error('route number is overflow');
                    }

                    buffer[offset++] = route >> 8 & 0xff;
                    buffer[offset++] = route & 0xff;
                } else {
                    if (route) {
                        buffer[offset++] = route.length & 0xff;
                        copyArray(buffer, offset, route, 0, route.length);
                        offset += route.length;
                    } else {
                        buffer[offset++] = 0;
                    }
                }

                return offset;
            };

            var encodeMsgBody = function encodeMsgBody(msg, buffer, offset) {
                copyArray(buffer, offset, msg, 0, msg.length);
                return offset + msg.length;
            };

            module.exports = Protocol;
        })('object' === (typeof module === 'undefined' ? 'undefined' : _typeof(module)) ? module.exports : this.Protocol = {}, 'object' === (typeof module === 'undefined' ? 'undefined' : _typeof(module)) ? Buffer : Uint8Array, this);
    });

    pomeloBuildObj.register("pomelonode-pomelo-protobuf/lib/client/protobuf.js", function (exports, requirePomelo, module) {
        /* ProtocolBuffer client 0.1.0*/

        /**
         * pomelo-protobuf
         * @author <zhang0935@gmail.com>
         */

        /**
         * Protocol buffer root
         * In browser, it will be window.protbuf
         */
        (function (exports, global) {
            var Protobuf = exports;

            Protobuf.init = function (opts) {
                //On the serverside, use serverProtos to encode messages send to client
                Protobuf.encoder.init(opts.encoderProtos);

                //On the serverside, user clientProtos to decode messages receive from clients
                Protobuf.decoder.init(opts.decoderProtos);
            };

            Protobuf.encode = function (key, msg) {
                return Protobuf.encoder.encode(key, msg);
            };

            Protobuf.decode = function (key, msg) {
                return Protobuf.decoder.decode(key, msg);
            };

            // exports to support for components
            module.exports = Protobuf;
        })('object' === (typeof module === 'undefined' ? 'undefined' : _typeof(module)) ? module.exports : this.protobuf = {}, this);

        /**
         * constants
         */
        (function (exports, global) {
            var constants = exports.constants = {};

            constants.TYPES = {
                uInt32: 0,
                sInt32: 0,
                int32: 0,
                double: 1,
                string: 2,
                message: 2,
                float: 5
            };
        })('undefined' !== typeof protobuf ? protobuf : module.exports, this);

        /**
         * util module
         */
        (function (exports, global) {

            var Util = exports.util = {};

            Util.isSimpleType = function (type) {
                return type === 'uInt32' || type === 'sInt32' || type === 'int32' || type === 'uInt64' || type === 'sInt64' || type === 'float' || type === 'double';
            };
        })('undefined' !== typeof protobuf ? protobuf : module.exports, this);

        /**
         * codec module
         */
        (function (exports, global) {

            var Codec = exports.codec = {};

            var buffer = new ArrayBuffer(8);
            var float32Array = new Float32Array(buffer);
            var float64Array = new Float64Array(buffer);
            var uInt8Array = new Uint8Array(buffer);

            Codec.encodeUInt32 = function (n) {
                var n = parseInt(n);
                if (isNaN(n) || n < 0) {
                    return null;
                }

                var result = [];
                do {
                    var tmp = n % 128;
                    var next = Math.floor(n / 128);

                    if (next !== 0) {
                        tmp = tmp + 128;
                    }
                    result.push(tmp);
                    n = next;
                } while (n !== 0);

                return result;
            };

            Codec.encodeSInt32 = function (n) {
                var n = parseInt(n);
                if (isNaN(n)) {
                    return null;
                }
                n = n < 0 ? Math.abs(n) * 2 - 1 : n * 2;

                return Codec.encodeUInt32(n);
            };

            Codec.decodeUInt32 = function (bytes) {
                var n = 0;

                for (var i = 0; i < bytes.length; i++) {
                    var m = parseInt(bytes[i]);
                    n = n + (m & 0x7f) * Math.pow(2, 7 * i);
                    if (m < 128) {
                        return n;
                    }
                }

                return n;
            };

            Codec.decodeSInt32 = function (bytes) {
                var n = this.decodeUInt32(bytes);
                var flag = n % 2 === 1 ? -1 : 1;

                n = (n % 2 + n) / 2 * flag;

                return n;
            };

            Codec.encodeFloat = function (float) {
                float32Array[0] = float;
                return uInt8Array;
            };

            Codec.decodeFloat = function (bytes, offset) {
                if (!bytes || bytes.length < offset + 4) {
                    return null;
                }

                for (var i = 0; i < 4; i++) {
                    uInt8Array[i] = bytes[offset + i];
                }

                return float32Array[0];
            };

            Codec.encodeDouble = function (double) {
                float64Array[0] = double;
                return uInt8Array.subarray(0, 8);
            };

            Codec.decodeDouble = function (bytes, offset) {
                if (!bytes || bytes.length < 8 + offset) {
                    return null;
                }

                for (var i = 0; i < 8; i++) {
                    uInt8Array[i] = bytes[offset + i];
                }

                return float64Array[0];
            };

            Codec.encodeStr = function (bytes, offset, str) {
                for (var i = 0; i < str.length; i++) {
                    var code = str.charCodeAt(i);
                    var codes = encode2UTF8(code);

                    for (var j = 0; j < codes.length; j++) {
                        bytes[offset] = codes[j];
                        offset++;
                    }
                }

                return offset;
            };

            /**
             * Decode string from utf8 bytes
             */
            Codec.decodeStr = function (bytes, offset, length) {
                var array = [];
                var end = offset + length;

                while (offset < end) {
                    var code = 0;

                    if (bytes[offset] < 128) {
                        code = bytes[offset];

                        offset += 1;
                    } else if (bytes[offset] < 224) {
                        code = ((bytes[offset] & 0x3f) << 6) + (bytes[offset + 1] & 0x3f);
                        offset += 2;
                    } else {
                        code = ((bytes[offset] & 0x0f) << 12) + ((bytes[offset + 1] & 0x3f) << 6) + (bytes[offset + 2] & 0x3f);
                        offset += 3;
                    }

                    array.push(code);
                }

                var str = '';
                for (var i = 0; i < array.length;) {
                    str += String.fromCharCode.apply(null, array.slice(i, i + 10000));
                    i += 10000;
                }

                return str;
            };

            /**
             * Return the byte length of the str use utf8
             */
            Codec.byteLength = function (str) {
                if (typeof str !== 'string') {
                    return -1;
                }

                var length = 0;

                for (var i = 0; i < str.length; i++) {
                    var code = str.charCodeAt(i);
                    length += codeLength(code);
                }

                return length;
            };

            /**
             * Encode a unicode16 char code to utf8 bytes
             */
            function encode2UTF8(charCode) {
                if (charCode <= 0x7f) {
                    return [charCode];
                } else if (charCode <= 0x7ff) {
                    return [0xc0 | charCode >> 6, 0x80 | charCode & 0x3f];
                } else {
                    return [0xe0 | charCode >> 12, 0x80 | (charCode & 0xfc0) >> 6, 0x80 | charCode & 0x3f];
                }
            }

            function codeLength(code) {
                if (code <= 0x7f) {
                    return 1;
                } else if (code <= 0x7ff) {
                    return 2;
                } else {
                    return 3;
                }
            }
        })('undefined' !== typeof protobuf ? protobuf : module.exports, this);

        /**
         * encoder module
         */
        (function (exports, global) {

            var protobuf = exports;
            var MsgEncoder = exports.encoder = {};

            var codec = protobuf.codec;
            var constant = protobuf.constants;
            var util = protobuf.util;

            MsgEncoder.init = function (protos) {
                this.protos = protos || {};
            };

            MsgEncoder.encode = function (route, msg) {
                //Get protos from protos map use the route as key
                var protos = this.protos[route];

                //Check msg
                if (!checkMsg(msg, protos)) {
                    return null;
                }

                //Set the length of the buffer 2 times bigger to prevent overflow
                var length = codec.byteLength(JSON.stringify(msg));

                //Init buffer and offset
                var buffer = new ArrayBuffer(length);
                var uInt8Array = new Uint8Array(buffer);
                var offset = 0;

                if (!!protos) {
                    offset = encodeMsg(uInt8Array, offset, protos, msg);
                    if (offset > 0) {
                        return uInt8Array.subarray(0, offset);
                    }
                }

                return null;
            };

            /**
             * Check if the msg follow the defination in the protos
             */
            function checkMsg(msg, protos) {
                if (!protos) {
                    return false;
                }

                for (var name in protos) {
                    var proto = protos[name];

                    //All required element must exist
                    switch (proto.option) {
                        case 'required':
                            if (typeof msg[name] === 'undefined') {
                                return false;
                            }
                        case 'optional':
                            if (typeof msg[name] !== 'undefined') {
                                var message = protos.__messages[proto.type] || MsgEncoder.protos['message ' + proto.type];
                                if (!!message) {
                                    checkMsg(msg[name], message);
                                }
                            }
                            break;
                        case 'repeated':
                            //Check nest message in repeated elements
                            var message = protos.__messages[proto.type] || MsgEncoder.protos['message ' + proto.type];
                            if (!!msg[name] && !!message) {
                                for (var i = 0; i < msg[name].length; i++) {
                                    if (!checkMsg(msg[name][i], message)) {
                                        return false;
                                    }
                                }
                            }
                            break;
                    }
                }

                return true;
            }

            function encodeMsg(buffer, offset, protos, msg) {
                for (var name in msg) {
                    if (!!protos[name]) {
                        var proto = protos[name];

                        switch (proto.option) {
                            case 'required':
                            case 'optional':
                                offset = writeBytes(buffer, offset, encodeTag(proto.type, proto.tag));
                                offset = encodeProp(msg[name], proto.type, offset, buffer, protos);
                                break;
                            case 'repeated':
                                if (msg[name].length > 0) {
                                    offset = encodeArray(msg[name], proto, offset, buffer, protos);
                                }
                                break;
                        }
                    }
                }

                return offset;
            }

            function encodeProp(value, type, offset, buffer, protos) {
                switch (type) {
                    case 'uInt32':
                        offset = writeBytes(buffer, offset, codec.encodeUInt32(value));
                        break;
                    case 'int32':
                    case 'sInt32':
                        offset = writeBytes(buffer, offset, codec.encodeSInt32(value));
                        break;
                    case 'float':
                        writeBytes(buffer, offset, codec.encodeFloat(value));
                        offset += 4;
                        break;
                    case 'double':
                        writeBytes(buffer, offset, codec.encodeDouble(value));
                        offset += 8;
                        break;
                    case 'string':
                        var length = codec.byteLength(value);

                        //Encode length
                        offset = writeBytes(buffer, offset, codec.encodeUInt32(length));
                        //write string
                        codec.encodeStr(buffer, offset, value);
                        offset += length;
                        break;
                    default:
                        var message = protos.__messages[type] || MsgEncoder.protos['message ' + type];
                        if (!!message) {
                            //Use a tmp buffer to build an internal msg
                            var tmpBuffer = new ArrayBuffer(codec.byteLength(JSON.stringify(value)));
                            var length = 0;

                            length = encodeMsg(tmpBuffer, length, message, value);
                            //Encode length
                            offset = writeBytes(buffer, offset, codec.encodeUInt32(length));
                            //contact the object
                            for (var i = 0; i < length; i++) {
                                buffer[offset] = tmpBuffer[i];
                                offset++;
                            }
                        }
                        break;
                }

                return offset;
            }

            /**
             * Encode reapeated properties, simple msg and object are decode differented
             */
            function encodeArray(array, proto, offset, buffer, protos) {
                var i = 0;

                if (util.isSimpleType(proto.type)) {
                    offset = writeBytes(buffer, offset, encodeTag(proto.type, proto.tag));
                    offset = writeBytes(buffer, offset, codec.encodeUInt32(array.length));
                    for (i = 0; i < array.length; i++) {
                        offset = encodeProp(array[i], proto.type, offset, buffer);
                    }
                } else {
                    for (i = 0; i < array.length; i++) {
                        offset = writeBytes(buffer, offset, encodeTag(proto.type, proto.tag));
                        offset = encodeProp(array[i], proto.type, offset, buffer, protos);
                    }
                }

                return offset;
            }

            function writeBytes(buffer, offset, bytes) {
                for (var i = 0; i < bytes.length; i++, offset++) {
                    buffer[offset] = bytes[i];
                }

                return offset;
            }

            function encodeTag(type, tag) {
                var value = constant.TYPES[type] || 2;
                return codec.encodeUInt32(tag << 3 | value);
            }
        })('undefined' !== typeof protobuf ? protobuf : module.exports, this);

        /**
         * decoder module
         */
        (function (exports, global) {
            var protobuf = exports;
            var MsgDecoder = exports.decoder = {};

            var codec = protobuf.codec;
            var util = protobuf.util;

            var buffer;
            var offset = 0;

            MsgDecoder.init = function (protos) {
                this.protos = protos || {};
            };

            MsgDecoder.setProtos = function (protos) {
                if (!!protos) {
                    this.protos = protos;
                }
            };

            MsgDecoder.decode = function (route, buf) {
                var protos = this.protos[route];

                buffer = buf;
                offset = 0;

                if (!!protos) {
                    return decodeMsg({}, protos, buffer.length);
                }

                return null;
            };

            function decodeMsg(msg, protos, length) {
                while (offset < length) {
                    var head = getHead();
                    var type = head.type;
                    var tag = head.tag;
                    var name = protos.__tags[tag];

                    switch (protos[name].option) {
                        case 'optional':
                        case 'required':
                            msg[name] = decodeProp(protos[name].type, protos);
                            break;
                        case 'repeated':
                            if (!msg[name]) {
                                msg[name] = [];
                            }
                            decodeArray(msg[name], protos[name].type, protos);
                            break;
                    }
                }

                return msg;
            }

            /**
             * Test if the given msg is finished
             */
            function isFinish(msg, protos) {
                return !protos.__tags[peekHead().tag];
            }

            /**
             * Get property head from protobuf
             */
            function getHead() {
                var tag = codec.decodeUInt32(getBytes());

                return {
                    type: tag & 0x7,
                    tag: tag >> 3
                };
            }

            /**
             * Get tag head without move the offset
             */
            function peekHead() {
                var tag = codec.decodeUInt32(peekBytes());

                return {
                    type: tag & 0x7,
                    tag: tag >> 3
                };
            }

            function decodeProp(type, protos) {
                switch (type) {
                    case 'uInt32':
                        return codec.decodeUInt32(getBytes());
                    case 'int32':
                    case 'sInt32':
                        return codec.decodeSInt32(getBytes());
                    case 'float':
                        var float = codec.decodeFloat(buffer, offset);
                        offset += 4;
                        return float;
                    case 'double':
                        var double = codec.decodeDouble(buffer, offset);
                        offset += 8;
                        return double;
                    case 'string':
                        var length = codec.decodeUInt32(getBytes());

                        var str = codec.decodeStr(buffer, offset, length);
                        offset += length;

                        return str;
                    default:
                        var message = protos.__messages[type] || MsgDecoder.protos['message ' + type];
                        if (!!protos && !!message) {
                            var length = codec.decodeUInt32(getBytes());
                            var msg = {};
                            decodeMsg(msg, message, offset + length);
                            return msg;
                        }
                        break;
                }
            }

            function decodeArray(array, type, protos) {
                if (util.isSimpleType(type)) {
                    var length = codec.decodeUInt32(getBytes());

                    for (var i = 0; i < length; i++) {
                        array.push(decodeProp(type));
                    }
                } else {
                    array.push(decodeProp(type, protos));
                }
            }

            function getBytes(flag) {
                var bytes = [];
                var pos = offset;
                flag = flag || false;

                var b;

                do {
                    b = buffer[pos];
                    bytes.push(b);
                    pos++;
                } while (b >= 128);

                if (!flag) {
                    offset = pos;
                }
                return bytes;
            }

            function peekBytes() {
                return getBytes(true);
            }
        })('undefined' !== typeof protobuf ? protobuf : module.exports, this);
    });

    pomeloBuildObj.register("pomelonode-pomelo-jsclient-websocket/lib/pomelo-client.js", function (exports, requirePomelo, module) {
        (function (self) {
            var JS_WS_CLIENT_TYPE = 'js-websocket';
            var JS_WS_CLIENT_VERSION = '0.0.1';

            var Protocol = self.Protocol;
            var Package = Protocol.Package;
            var Message = Protocol.Message;
            var EventEmitter = self.EventEmitter;
            var protobuf = self.protobuf;

            var RES_OK = 200;
            var RES_FAIL = 500;
            var RES_OLD_CLIENT = 501;

            if (typeof Object.create !== 'function') {
                Object.create = function (o) {
                    function F() {}

                    F.prototype = o;
                    return new F();
                };
            }

            var root = window;
            var pomelo = Object.create(EventEmitter.prototype); // object extend from object
            root.pomelo = pomelo;
            var socket = null;
            var reqId = 0;
            var callbacks = {};
            var handlers = {};
            //Map from request id to route
            var routeMap = {};

            var heartbeatInterval = 0;
            var heartbeatTimeout = 0;
            var nextHeartbeatTimeout = 0;
            var gapThreshold = 100; // heartbeat gap threashold
            var heartbeatId = null;
            var heartbeatTimeoutId = null;

            var handshakeCallback = null;

            var handshakeBuffer = {
                'sys': {
                    type: JS_WS_CLIENT_TYPE,
                    version: JS_WS_CLIENT_VERSION
                },
                'user': {}
            };

            var initCallback = null;

            pomelo.init = function (params, cb) {
                initCallback = cb;
                var host = params.host;
                var port = params.port;

                var wsStr = "ws://";

                if (params.wsStr) {
                    wsStr = params.wsStr;
                }

                var url = wsStr + host;
                if (port) {
                    url += ':' + port;
                }

                handshakeBuffer.user = params.user;
                handshakeCallback = params.handshakeCallback;
                initWebSocket(url, cb);
            };

            var initWebSocket = function initWebSocket(url, cb) {
                console.log('connect to ' + url);
                var onopen = function onopen(event) {
                    var obj = Package.encode(Package.TYPE_HANDSHAKE, Protocol.strencode(JSON.stringify(handshakeBuffer)));
                    send(obj);
                };
                var onmessage = function onmessage(event) {
                    processPackage(Package.decode(event.data), cb);
                    // new package arrived, update the heartbeat timeout
                    if (heartbeatTimeout) {
                        nextHeartbeatTimeout = Date.now() + heartbeatTimeout;
                    }
                };
                var onerror = function onerror(event) {
                    pomelo.emit('io-error', event);
                    console.warn('socket error: ', JSON.stringify(event));
                };
                var onclose = function onclose(event) {
                    pomelo.emit('close', event);
                    console.warn('socket close: ', JSON.stringify(event));
                    // //尝试修复断线后继续发心跳包后报错
                    // if (heartbeatId) {
                    //     clearTimeout(heartbeatId);
                    //     heartbeatId = null;
                    // }
                    //
                    // if (heartbeatTimeoutId) {
                    //     clearTimeout(heartbeatTimeoutId);
                    //     heartbeatTimeoutId = null;
                    // }
                };
                socket = new WebSocket(url);
                socket.binaryType = 'arraybuffer';
                socket.onopen = onopen;
                socket.onmessage = onmessage;
                socket.onerror = onerror;
                socket.onclose = onclose;
            };

            pomelo.disconnect = function () {
                if (socket) {
                    if (socket.disconnect) socket.disconnect();
                    if (socket.close) socket.close();
                    console.log('disconnect');
                    socket = null;
                }

                if (heartbeatId) {
                    clearTimeout(heartbeatId);
                    heartbeatId = null;
                }
                if (heartbeatTimeoutId) {
                    clearTimeout(heartbeatTimeoutId);
                    heartbeatTimeoutId = null;
                }
            };

            pomelo.request = function (route, msg, cb) {
                if (arguments.length === 2 && typeof msg === 'function') {
                    cb = msg;
                    msg = {};
                } else {
                    msg = msg || {};
                }
                route = route || msg.route;
                if (!route) {
                    return;
                }

                reqId++;
                /**
                 * 128及其倍数的reqId会导致服务端编解码出现异常,128及其倍数是个坑。绕过。
                 * //pomelo-protocol.js#243
                 *  do{
                        m = parseInt(bytes[offset]);
                        id += (m & 0x7f) << (7 * i);   //这个风骚的位移有bug
                        offset++;
                        i++;
                    }while(m >= 128); 
                 * 
                 */
                if (reqId % 128 == 0) {
                    reqId++;
                }

                sendMessage(reqId, route, msg);

                callbacks[reqId] = cb;
                routeMap[reqId] = route;
            };

            pomelo.notify = function (route, msg) {
                msg = msg || {};
                sendMessage(0, route, msg);
            };

            pomelo.clearCallback = function () {
                if (!socket) return;
                socket.onopen = null;
                socket.onmessage = null;
                socket.onerror = null;
                socket.onclose = null;
            };

            pomelo.isConnecting = function () {
                return socket && socket.readyState === WebSocket.CONNECTING;
            };

            pomelo.isOpen = function () {
                return socket && socket.readyState === WebSocket.OPEN;
            };

            pomelo.isClosed = function () {
                return socket && socket.readyState === WebSocket.CLOSED;
            };

            pomelo.isClosing = function () {
                return socket && socket.readyState === WebSocket.CLOSING;
            };

            var sendMessage = function sendMessage(reqId, route, msg) {
                var type = reqId ? Message.TYPE_REQUEST : Message.TYPE_NOTIFY;

                //compress message by protobuf
                var protos = !!pomelo.data.protos ? pomelo.data.protos.client : {};
                if (!!protos[route]) {
                    msg = protobuf.encode(route, msg);
                } else {
                    msg = Protocol.strencode(JSON.stringify(msg));
                }

                var compressRoute = 0;
                if (pomelo.dict && pomelo.dict[route]) {
                    route = pomelo.dict[route];
                    compressRoute = 1;
                }

                msg = Message.encode(reqId, type, compressRoute, route, msg);
                var packet = Package.encode(Package.TYPE_DATA, msg);
                send(packet);
            };

            var send = function send(packet) {
                if (socket) {
                    socket.send(packet.buffer);
                }
            };

            var handler = {};

            var heartbeat = function heartbeat(data) {
                if (!heartbeatInterval) {
                    // no heartbeat
                    return;
                }

                pomelo.emit('heartbeat recv');

                var obj = Package.encode(Package.TYPE_HEARTBEAT);
                if (heartbeatTimeoutId) {
                    clearTimeout(heartbeatTimeoutId);
                    heartbeatTimeoutId = null;
                }

                if (heartbeatId) {
                    // already in a heartbeat interval
                    return;
                }

                heartbeatId = setTimeout(function () {
                    heartbeatId = null;
                    send(obj);

                    nextHeartbeatTimeout = Date.now() + heartbeatTimeout;
                    heartbeatTimeoutId = setTimeout(heartbeatTimeoutCb, heartbeatTimeout);
                }, heartbeatInterval);
            };

            var heartbeatTimeoutCb = function heartbeatTimeoutCb() {
                var gap = nextHeartbeatTimeout - Date.now();
                if (gap > gapThreshold) {
                    heartbeatTimeoutId = setTimeout(heartbeatTimeoutCb, gap);
                } else {
                    console.warn('server heartbeat timeout');
                    pomelo.emit('heartbeat timeout');
                    pomelo.disconnect();
                }
            };

            var handshake = function handshake(data) {
                data = JSON.parse(Protocol.strdecode(data));
                if (data.code === RES_OLD_CLIENT) {
                    pomelo.emit('error', 'client version not fullfill');
                    return;
                }

                if (data.code !== RES_OK) {
                    pomelo.emit('error', 'handshake fail');
                    return;
                }

                handshakeInit(data);

                var obj = Package.encode(Package.TYPE_HANDSHAKE_ACK);
                send(obj);
                if (initCallback) {
                    initCallback(socket);
                    initCallback = null;
                }
            };

            var onData = function onData(data) {
                //probuff decode
                var msg = Message.decode(data);

                if (msg.id > 0) {
                    msg.route = routeMap[msg.id];
                    delete routeMap[msg.id];
                    if (!msg.route) {
                        return;
                    }
                }

                msg.body = deCompose(msg);

                processMessage(pomelo, msg);
            };

            var onKick = function onKick(data) {
                var info = JSON.parse(Protocol.strdecode(data));

                var reason = "kick";
                if (info.hasOwnProperty("reason")) {
                    reason = info["reason"];
                }

                pomelo.emit('onKick', reason);
            };

            handlers[Package.TYPE_HANDSHAKE] = handshake;
            handlers[Package.TYPE_HEARTBEAT] = heartbeat;
            handlers[Package.TYPE_DATA] = onData;
            handlers[Package.TYPE_KICK] = onKick;

            var processPackage = function processPackage(msg) {
                handlers[msg.type](msg.body);
            };

            var processMessage = function processMessage(pomelo, msg) {
                if (!msg.id) {
                    // server push message
                    pomelo.emit(msg.route, msg);
                    return;
                }

                //if have a id then find the callback function with the request
                var cb = callbacks[msg.id];

                delete callbacks[msg.id];
                if (typeof cb !== 'function') {
                    return;
                }

                cb(msg);
                return;
            };

            var processMessageBatch = function processMessageBatch(pomelo, msgs) {
                for (var i = 0, l = msgs.length; i < l; i++) {
                    processMessage(pomelo, msgs[i]);
                }
            };

            var deCompose = function deCompose(msg) {
                var protos = !!pomelo.data.protos ? pomelo.data.protos.server : {};
                var abbrs = pomelo.data.abbrs;
                var route = msg.route;

                //Decompose route from dict
                if (msg.compressRoute) {
                    if (!abbrs[route]) {
                        return {};
                    }

                    route = msg.route = abbrs[route];
                }
                if (!!protos[route]) {
                    return protobuf.decode(route, msg.body);
                } else {
                    return JSON.parse(Protocol.strdecode(msg.body));
                }

                return msg;
            };

            var handshakeInit = function handshakeInit(data) {
                if (data.sys && data.sys.heartbeat) {
                    heartbeatInterval = data.sys.heartbeat * 1000; // heartbeat interval
                    heartbeatTimeout = heartbeatInterval * 2; // max heartbeat timeout
                } else {
                    heartbeatInterval = 0;
                    heartbeatTimeout = 0;
                }

                initData(data);

                if (typeof handshakeCallback === 'function') {
                    handshakeCallback(data.user);
                }
            };

            //Initilize data used in pomelo client
            var initData = function initData(data) {
                if (!data || !data.sys) {
                    return;
                }
                pomelo.data = pomelo.data || {};
                var dict = data.sys.dict;
                var protos = data.sys.protos;

                //Init compress dict
                if (dict) {
                    pomelo.data.dict = dict;
                    pomelo.data.abbrs = {};

                    for (var route in dict) {
                        pomelo.data.abbrs[dict[route]] = route;
                    }
                }

                //Init protobuf protos
                if (protos) {
                    pomelo.data.protos = {
                        server: protos.server || {},
                        client: protos.client || {}
                    };
                    if (!!protobuf) {
                        protobuf.init({ encoderProtos: protos.client, decoderProtos: protos.server });
                    }
                }
            };

            module.exports = pomelo;
        })(this);
    });

    pomeloBuildObj.register("boot/index.js", function (exports, requirePomelo, module) {
        var Emitter = requirePomelo('emitter');
        this.EventEmitter = Object.create(Emitter);

        var protocol = requirePomelo('pomelo-protocol');
        this.Protocol = protocol;

        var protobuf = requirePomelo('pomelo-protobuf');
        this.protobuf = protobuf;

        var pomelo = requirePomelo('pomelo-jsclient-websocket');
        this.pomelo = pomelo;
    });
    pomeloBuildObj.alias("boot/index.js", "pomelo-client/deps/boot/index.js");
    pomeloBuildObj.alias("component-emitter/index.js", "boot/deps/emitter/index.js");
    pomeloBuildObj.alias("component-indexof/index.js", "component-emitter/deps/indexof/index.js");

    pomeloBuildObj.alias("NetEase-pomelo-protocol/lib/protocol.js", "boot/deps/pomelo-protocol/lib/protocol.js");
    pomeloBuildObj.alias("NetEase-pomelo-protocol/lib/protocol.js", "boot/deps/pomelo-protocol/index.js");
    pomeloBuildObj.alias("NetEase-pomelo-protocol/lib/protocol.js", "NetEase-pomelo-protocol/index.js");

    pomeloBuildObj.alias("pomelonode-pomelo-protobuf/lib/client/protobuf.js", "boot/deps/pomelo-protobuf/lib/client/protobuf.js");
    pomeloBuildObj.alias("pomelonode-pomelo-protobuf/lib/client/protobuf.js", "boot/deps/pomelo-protobuf/index.js");
    pomeloBuildObj.alias("pomelonode-pomelo-protobuf/lib/client/protobuf.js", "pomelonode-pomelo-protobuf/index.js");

    pomeloBuildObj.alias("pomelonode-pomelo-jsclient-websocket/lib/pomelo-client.js", "boot/deps/pomelo-jsclient-websocket/lib/pomelo-client.js");
    pomeloBuildObj.alias("pomelonode-pomelo-jsclient-websocket/lib/pomelo-client.js", "boot/deps/pomelo-jsclient-websocket/index.js");
    pomeloBuildObj.alias("pomelonode-pomelo-jsclient-websocket/lib/pomelo-client.js", "pomelonode-pomelo-jsclient-websocket/index.js");

    pomeloBuildObj.requirePomelo("boot");

    return pomeloBuildObj;
};

window.pomeloBuild = pomeloBuild;

cc._RF.pop();
        }
        if (CC_EDITOR) {
            __define(__module.exports, __require, __module);
        }
        else {
            cc.registerModuleFunc(__filename, function () {
                __define(__module.exports, __require, __module);
            });
        }
        })();
        //# sourceMappingURL=pomeloBuild.js.map
        